/**
 * 地址解析服务
 * 用于批量获取GPS坐标对应的地址信息
 */
import { batchGetAddresses } from '@/api/shipment'

export class AddressService {
  constructor() {
    this.addressCache = new Map() // 地址缓存
  }

  /**
   * 生成坐标缓存键
   */
  getCacheKey(lat, lng) {
    // 保留6位小数作为缓存键，避免重复查询相近坐标
    return `${lat.toFixed(6)}_${lng.toFixed(6)}`
  }

  /**
   * 批量获取地址信息
   * @param {Array} coordinates 坐标列表 [{lat, lng}, ...]
   * @returns {Promise<Array>} 地址信息数组
   */
  async batchGetAddresses(coordinates) {
    if (!coordinates || coordinates.length === 0) {
      return []
    }

    // 过滤需要查询的坐标（排除已缓存的）
    const uncachedCoordinates = []
    const results = []

    coordinates.forEach((coord, index) => {
      const cacheKey = this.getCacheKey(coord.lat, coord.lng)
      
      if (this.addressCache.has(cacheKey)) {
        // 使用缓存
        results[index] = {
          ...this.addressCache.get(cacheKey),
          coordinates: coord
        }
      } else {
        // 标记需要查询
        uncachedCoordinates.push({
          ...coord,
          originalIndex: index
        })
      }
    })

    // 批量查询未缓存的地址
    if (uncachedCoordinates.length > 0) {
      try {
        const response = await batchGetAddresses(uncachedCoordinates)
        
        if (response.code === 200 && response.data && response.data.addresses) {
          const addresses = response.data.addresses
          
          // 处理查询结果
          addresses.forEach((addressResult, i) => {
            const originalCoord = uncachedCoordinates[i]
            const originalIndex = originalCoord.originalIndex
            
            // 缓存结果
            const cacheKey = this.getCacheKey(originalCoord.lat, originalCoord.lng)
            this.addressCache.set(cacheKey, addressResult)
            
            // 设置结果
            results[originalIndex] = {
              ...addressResult,
              coordinates: {
                lat: originalCoord.lat,
                lng: originalCoord.lng
              }
            }
          })
        }
      } catch (error) {
        console.error('批量获取地址失败:', error)
        
        // 为未查询成功的坐标设置默认值
        uncachedCoordinates.forEach(coord => {
          results[coord.originalIndex] = {
            success: false,
            address: '地址获取失败',
            error: error.message || '网络错误',
            coordinates: {
              lat: coord.lat,
              lng: coord.lng
            }
          }
        })
      }
    }

    return results
  }

  /**
   * 获取单个地址信息
   * @param {number} lat 纬度
   * @param {number} lng 经度
   * @returns {Promise<Object>} 地址信息
   */
  async getAddress(lat, lng) {
    const results = await this.batchGetAddresses([{ lat, lng }])
    return results[0] || {
      success: false,
      address: '地址获取失败',
      coordinates: { lat, lng }
    }
  }

  /**
   * 格式化地址用于显示
   * @param {Object} addressResult 地址查询结果
   * @returns {string} 格式化后的地址
   */
  formatAddress(addressResult) {
    if (!addressResult) {
      return '地址未知'
    }
    
    if (addressResult.success) {
      return addressResult.address || '地址未知'
    } else {
      return `地址获取失败: ${addressResult.error || '未知错误'}`
    }
  }

  /**
   * 清空地址缓存
   */
  clearCache() {
    this.addressCache.clear()
  }

  /**
   * 获取缓存统计信息
   */
  getCacheStats() {
    return {
      cacheSize: this.addressCache.size,
      cacheKeys: Array.from(this.addressCache.keys())
    }
  }
}

// 创建全局实例
export const addressService = new AddressService()